#pragma once

#include <iostream>
#include <memory>
#include "Log.hpp"
#include "Socket.hpp"
#include "IOService.hpp"
#include "reactor.hpp"
using namespace SocketModule;
// * 负责获取链接的模块
// * 连接服务器
class listener : public connection
{

public:
    listener(int port) : _port(port),
                        _listensock(std::make_unique<TcpSocket>())
    {
        _listensock->BuildTcpSocketMethod(_port);
        setSockfd(_listensock->Fd());
        setEvents(EPOLLIN | EPOLLET);
    }
    ~listener()
    {
        _listensock->Close();
    }
    void accepter(std::shared_ptr<connection_t> conn)
    {
        
    }
    int sockfd() { return _listensock->Fd(); }

     // 回调指针
    virtual void recever() override
    {
        // 读事件就绪，而是listensock就绪
        // IO处理 ---获取新的链接
        // 你怎么知道，一次来的就是一个链接呢，怎么保证以此读完
        while (true)
        {
            InetAddr peer;
            int errcode = 0;
            // accept 非阻塞的时候，就是IO，我们就像处理read一样·处理read
            int sockfd = _listensock->Accepter(&peer, &errcode);

            if (sockfd > 0)
            {
                // get success
                // 我们还不意外的不能直接读取   
                // sockfd， 添加epoll
                // epollserver 只认 connection
                LOG(LogLevel::DEBUG) << "accepter success!!";
                // 普通的文件描述符， 处理 IO的， 也是connection
                // * 1.设置文件描述符位非阻塞
                setNonBlock(sockfd);
                // * 2. sockfd包装为connection
                auto conn = std::make_shared<IOService>(sockfd);
                conn->registerOnMessage(); // 注册一个内容回调
                // * 3. 插入到epollServer 
                getOwner()->insertConnection(conn);
            }
            else
            {
                if (errcode == EAGAIN || EWOULDBLOCK)
                {
                    LOG(LogLevel::DEBUG) << "accept all connection ... done";
                    break;
                }
                else if (errcode == EINTR)
                {
                    LOG(LogLevel::DEBUG) << "accept interrupted by signal. continue...";
                    break;
                }
                else
                {
                    LOG(LogLevel::WARNING) << "accept error, ignore...";
                    break;
                }
            }
        }
    }
    virtual void sender() override
    {

    }
    virtual void excepter() override
    {

    }

private:
    std::unique_ptr<Socket> _listensock;
    int _port;
};